home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1996 February: Tool Chest / Apple Developer CD Series Tool Chest February 1996 (Apple Computer)(1996).iso / Sample Code / AOCE Sample Code / PowerTalk Access Modules / Sample SMSAM / SampleSMSAM Source / BuildingBlocks / OCEObjects.h < prev    next >
Encoding:
C/C++ Source or Header  |  1995-07-28  |  42.0 KB  |  981 lines  |  [TEXT/KAHL]
  1. /*
  2.     File:        OCEObjects.h
  3.  
  4.     Copyright:    © 1991-1994 by Apple Computer, Inc.
  5.                 All rights reserved.
  6.  
  7.     Part of the AOCE Sample SMSAM Package.  Consult the license
  8.     which came with this software for your specific legal rights.
  9.  
  10. */
  11.  
  12.  
  13.  
  14. #ifndef    __OCEOBJECTS__
  15. #define    __OCEOBJECTS__
  16.  
  17. #ifndef    __OCE__
  18. #include "OCE.h"
  19. #endif
  20.  
  21. #ifndef __OCEMAIL__
  22. #ifndef THINK_CPLUS
  23. #include <OCEMail.h>
  24. #else
  25. #include "OCEMail.h"
  26. #endif
  27. #endif
  28.  
  29. #ifndef    __DIRECTOBJECT__
  30. #include "DirectObject.h"
  31. #endif
  32.  
  33. #pragma push
  34. #pragma segment OCEObjects
  35.  
  36. class ostream;
  37. class TAbstractFile;
  38.  
  39. /***********************************|****************************************/
  40.  
  41. // these routines are used to toggle frequent validity
  42. // checking of objects during internal operations
  43.  
  44. extern void SetOCEObjectsInternalValidityChecking ( Boolean = true );    // for frequent internal validity checks
  45. extern Boolean GetOCEObjectsInternalValidityChecking ();
  46.  
  47. // if we are in debug mode, then perform frequent internal checks within OCEObject classes
  48.  
  49. #if defined ( debug ) || defined ( DEBUG )
  50.     #define    INTERNAL_CHECKS
  51. #else
  52.     #undef    INTERNAL_CHECKS
  53. #endif
  54.  
  55. /*============================================================================
  56.  
  57.     TRString is a class which represents an OCE RString.
  58.  
  59.     Some examples of OOP operations that you can perform with TRStrings are:
  60.  
  61.         TRString r1 ( (ProtoRString*) p );    // construct from ProtoRString*
  62.         TRString r2 ( "String", smGreek );    // construct from C string with script
  63.         TRString r3 ( "\pString" );            // construct from Pascal string
  64.  
  65.         r1 = r2;                            // assign from TRString
  66.         r1 = (RString&) s;                    // assign from RString
  67.         r1 = (RString*) p;                    // safe assign from RString*
  68.         r1 = "String";                        // assign from C string
  69.         r1 = "\pString";                    // assign from Pascal string
  70.  
  71.         if ( r1 >= r2 ) …                    // compare with TRString
  72.         if ( r1 < r2 ) …                    // compare with TRString
  73.         if ( r1 > s ) …                        // compare with RString
  74.         if ( r1 == "String" ) …                // compare with C string
  75.         if ( r1 != "\pString" ) …            // compare with Pascal string
  76.  
  77.         OCEPackPathName ( r1, 1, … )        // autoconvert to const RStringPtr
  78.         strcpy ( s, r1 );                    // autoconvert to const char*
  79.         DrawString ( r1 );                    // autoconvert to const StringPtr
  80.  
  81.         r1 [ 3 ] = 'X';                        // safe character setter
  82.         Byte c = r1 [ 24 ];                    // safe character getter
  83.  
  84.         r1.SetLength ( 21 );                // length setting
  85.         short l = r1.GetLength ();            // length getting
  86.  
  87.         r1.SetScript ( smJapanese );        // script setting
  88.         short s = r1.SetScript ();            // script getting
  89.  
  90.         r1.SetKind ( kOCEDirName );            // kind setting
  91.         RStringKind k = r1.GetKind ();        // kind getting
  92.  
  93.         r1.MakeUppercase ();                // convert to upper case
  94.         r1.MakeLowercase ();                // convert to lower case
  95.  
  96.         TAbstractFile& file …
  97.         r1.Write ( file );                    // write object to file
  98.         r1.Read ( file );                    // read object from file
  99.  
  100.         cout << "R = " << r1 << '\n';        // stream out to console
  101.  
  102. ----------------------------------------------------------------------------*/
  103.  
  104. typedef const RString* ConstRStringPtr;
  105. typedef const ConstRStringPtr ConstRStringPtrArray [];
  106.  
  107. class TRString : public TDirectObject
  108. {
  109. public:        TRString ();
  110.             TRString ( CharacterSet, RStringKind = kOCEGenericSensitive );
  111.             TRString ( const char*, CharacterSet = smRoman, RStringKind = kOCEGenericSensitive );
  112.             TRString ( const StringPtr, CharacterSet = smRoman, RStringKind = kOCEGenericSensitive );
  113.             TRString ( const void*, unsigned short length, CharacterSet = smRoman, RStringKind = kOCEGenericSensitive );
  114.             TRString ( const TRString& );
  115.             TRString ( const TRString&, RStringKind newKind );
  116.             TRString ( const RString&, RStringKind = kOCEGenericSensitive );
  117.             TRString ( const RString*, RStringKind = kOCEGenericSensitive );
  118.             ~TRString ();
  119.  
  120. // assignment operators ----------------------------------------------------
  121.  
  122.             TRString&                operator = ( const TRString& );
  123.             TRString&                operator = ( const RString& );
  124.             TRString&                operator = ( const RString* );
  125.             TRString&                operator = ( const char* );
  126.             TRString&                operator = ( const StringPtr );
  127.  
  128. // conversion operators -----------------------------------------------------
  129.  
  130.     // these 4 routines provide read-only access, if you cast result to non-const, you’ll shoot yourself
  131.                                     operator const RString* () const;
  132.                                     operator const RString& () const;
  133.                                     operator const char* () const;
  134.                                     operator const StringPtr () const;
  135.  
  136. // accessor functions ------------------------------------------------------
  137.  
  138.     // caller must have allocated the data passed to these 3 functions
  139.             Boolean                    GetString ( RString&, unsigned short maxChars ) const;
  140.             Boolean                    GetString ( StringPtr, unsigned short maxChars ) const;
  141.             Boolean                    GetString ( char*, unsigned short maxChars ) const;
  142.  
  143.     // caller will own the data allocated and returned by these 3 functions
  144.             RString*                GetNewRString () const;
  145.             StringPtr                GetNewStringPtr () const;
  146.             char*                    GetNewString () const;
  147.  
  148.     // safe setter/getters for individual chars
  149.             Byte&                    operator [] ( unsigned short zeroBasedIndex ) const;
  150.  
  151.             unsigned short            SetLength ( unsigned short );
  152.             unsigned short            GetLength () const;
  153.  
  154.             void                    SetScript ( CharacterSet );
  155.             CharacterSet            GetScript () const;
  156.  
  157.             void                    SetKind ( RStringKind );
  158.             RStringKind                GetKind () const;
  159.  
  160.             void                    MakeLowercase ();
  161.             void                    MakeUppercase ();
  162.  
  163. // comparison operators ----------------------------------------------------
  164.  
  165.             Boolean                    operator == ( const TRString& ) const;
  166.             Boolean                    operator == ( const RString& ) const;
  167.             Boolean                    operator == ( const char* ) const;
  168.             Boolean                    operator == ( const StringPtr ) const;
  169.  
  170.             Boolean                    operator != ( const TRString& ) const;
  171.             Boolean                    operator != ( const RString& ) const;
  172.             Boolean                    operator != ( const char* ) const;
  173.             Boolean                    operator != ( const StringPtr ) const;
  174.  
  175.             Boolean                    operator > ( const TRString& ) const;
  176.             Boolean                    operator > ( const RString& ) const;
  177.             Boolean                    operator > ( const char* ) const;
  178.             Boolean                    operator > ( const StringPtr ) const;
  179.  
  180.             Boolean                    operator < ( const TRString& ) const;
  181.             Boolean                    operator < ( const RString& ) const;
  182.             Boolean                    operator < ( const char* ) const;
  183.             Boolean                    operator < ( const StringPtr ) const;
  184.  
  185. // comparison methods -------------------------------------------------------
  186.  
  187.             long                    Compare ( const TRString& ) const;
  188.             long                    Compare ( const RString& ) const;
  189.             long                    Compare ( const char* ) const;
  190.             long                    Compare ( const StringPtr ) const;
  191.  
  192. // i/o methods --------------------------------------------------------------
  193.  
  194.             Boolean                    Read ( TAbstractFile& );
  195.             Boolean                    Write ( TAbstractFile& ) const;
  196.     virtual    ostream&                operator >> ( ostream& ) const;
  197.  
  198. // utility methods ----------------------------------------------------------
  199.  
  200.     static    unsigned short            GetLogicalLength ( const RString* );
  201.     static    unsigned short            GetPhysicalSize ( unsigned short logicalLength );
  202.     static    unsigned short            GetLogicalSize ( unsigned short physicalSize );
  203.     static    unsigned short            GetPhysicalSize ( const RString* );
  204.  
  205. // debugging methods --------------------------------------------------------
  206.  
  207.             Boolean                    IsValid () const;
  208.     static    Boolean                    IsValid ( const TRString* );
  209.     static    Boolean                    IsValid ( ConstRStringPtr, RStringKind );
  210.  
  211. protected:    RString*                fString;
  212.             RStringKind                fKind;
  213.  
  214.             Boolean                    IsValidInternal () const;
  215.             Boolean                    IsValidIndex ( unsigned short ) const;
  216.  
  217.     static    RString*                Allocate ( unsigned short logicalLength, CharacterSet script = smRoman, const void* source = nil );
  218.     static    void                    Deallocate ( RString*& );
  219.     static    Boolean                    IsValidInternal ( const RString*, RStringKind );
  220. };
  221.  
  222. /***********************************|****************************************/
  223.  
  224. class TDirectoryName : public TRString
  225. {
  226. public:        TDirectoryName ( CharacterSet = smRoman );
  227.             TDirectoryName ( const char*, CharacterSet = smRoman );
  228.             TDirectoryName ( const StringPtr, CharacterSet = smRoman );
  229.             TDirectoryName ( const void*, unsigned short length, CharacterSet = smRoman );
  230.             TDirectoryName ( const TDirectoryName& );
  231.             TDirectoryName ( const DirectoryName& );
  232.             TDirectoryName ( const DirectoryName* );
  233.             TDirectoryName ( const TRString& );
  234.             TDirectoryName ( const RString& );
  235.             TDirectoryName ( const RString* );
  236.             ~TDirectoryName ();
  237.  
  238. // conversion operators -----------------------------------------------------
  239.  
  240.     // these 2 routines provide read-only access, if you cast result to non-const, you’ll shoot yourself
  241.                                     operator const DirectoryName* () const;
  242.                                     operator const DirectoryName& () const;
  243. };
  244.  
  245. /***********************************|****************************************/
  246.  
  247. class TCreationID : public TDirectObject
  248. {
  249. public:        TCreationID (); // defaults to (0,0)
  250.             TCreationID ( unsigned long a, unsigned long b = 0 );
  251.             TCreationID ( const TCreationID& );
  252.             TCreationID ( const CreationID& );
  253.             TCreationID ( const CreationID* );
  254.             ~TCreationID ();
  255.  
  256. // conversion operators -----------------------------------------------------
  257.  
  258.                                     operator const CreationID* () const;
  259.                                     operator const CreationID& () const;
  260.  
  261. // assignment operators ----------------------------------------------------
  262.  
  263.             TCreationID&            operator = ( const TCreationID& );
  264.             TCreationID&            operator = ( const CreationID& );
  265.  
  266. // comparison methods -------------------------------------------------------
  267.  
  268.             Boolean                    operator == ( const TCreationID& ) const;
  269.             Boolean                    operator == ( const CreationID& ) const;
  270.  
  271.             Boolean                    operator != ( const TCreationID& ) const;
  272.             Boolean                    operator != ( const CreationID& ) const;
  273.  
  274. // access methods -----------------------------------------------------------
  275.  
  276.             Boolean                    IsNull () const;
  277.             void                    GetID ( CreationID& ) const;
  278.             void                    GetID ( unsigned long& a, unsigned long& b ) const;
  279.  
  280. // i/o methods --------------------------------------------------------------
  281.  
  282.             Boolean                    Read ( TAbstractFile& );
  283.             Boolean                    Write ( TAbstractFile& ) const;
  284.     virtual    ostream&                operator >> ( ostream& ) const;
  285.  
  286. protected:    CreationID                fID;
  287. };
  288.  
  289. /***********************************|****************************************/
  290.  
  291. class TDirDiscriminator : public TDirectObject
  292. {
  293. public:        TDirDiscriminator ();
  294.             TDirDiscriminator ( OCEDirectoryKind signature, unsigned long misc = 0 );
  295.             TDirDiscriminator ( const TDirDiscriminator& d );
  296.             TDirDiscriminator ( const DirDiscriminator& d );
  297.             TDirDiscriminator ( const DirDiscriminator* d );
  298.             ~TDirDiscriminator ();
  299.  
  300. // conversion operators -----------------------------------------------------
  301.  
  302.                                     operator DirDiscriminator* () const;
  303.                                     operator DirDiscriminator& () const;
  304.  
  305. // assignment operators ----------------------------------------------------
  306.  
  307.             TDirDiscriminator&        operator = ( const TDirDiscriminator& );
  308.             TDirDiscriminator&        operator = ( const OCEDirectoryKind& );
  309.             TDirDiscriminator&        operator = ( const DirDiscriminator& );
  310.             TDirDiscriminator&        operator = ( const DirDiscriminator* );
  311.  
  312. // comparison methods -------------------------------------------------------
  313.  
  314.             Boolean                    operator == ( const TDirDiscriminator& ) const;
  315.             Boolean                    operator == ( const DirDiscriminator& ) const;
  316.  
  317.             Boolean                    operator != ( const TDirDiscriminator& ) const;
  318.             Boolean                    operator != ( const DirDiscriminator& ) const;
  319.  
  320. // access methods -----------------------------------------------------------
  321.  
  322.             void                    GetDiscriminator ( DirDiscriminator& ) const;
  323.             void                    GetDiscriminator ( OCEDirectoryKind& a, unsigned long& b ) const;
  324.  
  325. // i/o methods --------------------------------------------------------------
  326.  
  327.             Boolean                    Read ( TAbstractFile& );
  328.             Boolean                    Write ( TAbstractFile& ) const;
  329.     virtual    ostream&                operator >> ( ostream& ) const;
  330.  
  331. protected:    DirDiscriminator        fDiscriminator;
  332. };
  333.  
  334. /***********************************|****************************************/
  335.  
  336. class TDirectory : public TDirectObject
  337. {
  338. public:        TDirectory ();
  339.             TDirectory ( const TDirectoryName& );
  340.             TDirectory ( const TDirectoryName&, const TDirDiscriminator& );
  341.             TDirectory ( const TDirectory& );
  342.             TDirectory ( const RString* );
  343.             TDirectory ( const DirectoryName*, DirDiscriminator* = nil );
  344.             ~TDirectory ();
  345.  
  346. // assignment operators ----------------------------------------------------
  347.  
  348.             TDirectory&                operator = ( const TDirectory& );
  349.  
  350. // comparison methods -------------------------------------------------------
  351.  
  352.             Boolean                    operator == ( const TDirectory& ) const;
  353.             Boolean                    operator != ( const TDirectory& ) const;
  354.  
  355. // setters/getters ----------------------------------------------------------
  356.  
  357.             void                    SetName ( const TDirectoryName& );
  358.             Boolean                 GetName ( TDirectoryName& r ) const;
  359.             const TDirectoryName&    GetName () const;
  360.  
  361.             void                    SetDiscriminator ( const TDirDiscriminator& );
  362.             Boolean                 GetDiscriminator ( TDirDiscriminator& ) const;
  363.         const TDirDiscriminator&     GetDiscriminator () const;
  364.  
  365. // i/o methods --------------------------------------------------------------
  366.  
  367.             Boolean                    Read ( TAbstractFile& );
  368.             Boolean                    Write ( TAbstractFile& ) const;
  369.     virtual    ostream&                operator >> ( ostream& ) const;
  370.  
  371. protected:    TDirectoryName            fName;
  372.             TDirDiscriminator        fDiscriminator;
  373. };
  374.  
  375. /***********************************|****************************************/
  376.  
  377. class TPathName : public TDirectObject
  378. {
  379. public:        TPathName ();
  380.             TPathName ( const PackedPathName& p );
  381.             TPathName ( const PackedPathName* p );
  382.             TPathName ( const TPathName& );
  383.             TPathName ( const RStringPtr * /* ConstRStringPtrArray */, unsigned short );
  384.             TPathName ( const TRString& r1 );
  385.             TPathName ( const TRString& r1, const TRString& r2 );
  386.             TPathName ( const TRString& r1, const TRString& r2, const TRString& r3 );
  387.             ~TPathName ();
  388.  
  389. // conversion operators -----------------------------------------------------
  390.  
  391.     // these 2 routines provide read-only access, if you cast result to non-const, you’ll shoot yourself
  392.                                     operator const PackedPathName* () const;
  393.                                     operator const PackedPathName& () const;
  394.  
  395. // assignment operators ----------------------------------------------------
  396.  
  397.             TPathName&                operator = ( const TPathName& );
  398.             TPathName&                operator = ( const PackedPathName& );
  399.             TPathName&                operator = ( const PackedPathName* );
  400.  
  401. // comparison methods -------------------------------------------------------
  402.  
  403.             Boolean                    operator == ( const TPathName& ) const;
  404.             Boolean                    operator == ( const PackedPathName& ) const;
  405.  
  406.             Boolean                    operator != ( const TPathName& ) const;
  407.             Boolean                    operator != ( const PackedPathName& ) const;
  408.  
  409.             Boolean                    IsNull () const;
  410.             unsigned short             GetNodeCount () const;
  411.             Boolean                    IsValidIndex ( unsigned short oneBasedIndex ) const;
  412.  
  413.             Boolean                 SetNode ( unsigned short oneBasedIndex, const TRString& r );
  414.             Boolean                 GetNode ( unsigned short oneBasedIndex, TRString& r ) const;
  415.             const RString&            operator [] ( unsigned short zeroBasedIndex ) const;
  416.  
  417.             PackedPathName*         GetNewPackedPath () const;
  418.  
  419. // i/o methods --------------------------------------------------------------
  420.  
  421.             Boolean                    Read ( TAbstractFile& );
  422.             Boolean                    Write ( TAbstractFile& ) const;
  423.     virtual    ostream&                operator >> ( ostream& ) const;
  424.  
  425. // utility methods ----------------------------------------------------------
  426.  
  427.     static    unsigned short            GetPhysicalSize ( const PackedPathName* );
  428.  
  429. // debugging methods --------------------------------------------------------
  430.  
  431.             Boolean                    IsValid () const;
  432.     static    Boolean                    IsValid ( const PackedPathName* );
  433.  
  434. protected:    PackedPathName*            fPacked;
  435.             ConstRStringPtr*        fCache;
  436.  
  437.             Boolean                    IsValidInternal () const;
  438.             void                    InvalidateCache () const;
  439.             void                    ValidateCache () const;
  440.             void                    Deallocate ();    // invalidates cache too
  441.  
  442.     static    PackedPathName*            Allocate ( const TRString* [], unsigned short );
  443.     static    PackedPathName*            Allocate ( RStringPtr [], unsigned short );
  444.     static    PackedPathName*            Allocate ( const PackedPathName* );
  445.     static    PackedPathName*            Allocate ( unsigned short bytes );
  446.     static    ConstRStringPtr*        AllocateArray ( const TRString* [], unsigned short );
  447.     static    ConstRStringPtr*        AllocateArray ( const PackedPathName* );
  448.     static    void                    Deallocate ( PackedPathName*& );
  449.     static    Boolean                    IsValidInternal ( const PackedPathName* p );
  450. };
  451.  
  452. /***********************************|****************************************/
  453.  
  454. class TRLI : public TDirectObject
  455. {
  456. public:        TRLI ();
  457.             TRLI ( const PackedRLI& );
  458.             TRLI ( const PackedRLI* );
  459.             TRLI ( const RLI* );
  460.             TRLI ( const RLI& );
  461.             TRLI ( const TRLI& );
  462.             TRLI ( const TDirectory&, const TPathName&, DNodeNum = 0 );
  463.             TRLI ( const TDirectory&, DNodeNum );
  464.             ~TRLI ();
  465.  
  466. // conversion operators -----------------------------------------------------
  467.  
  468.     // these 4 routines provide read-only access, if you cast result to non-const, you’ll shoot yourself
  469.                                     operator const PackedRLI* () const;
  470.                                     operator const PackedRLI& () const;
  471.                                     operator const RLI* () const;
  472.                                     operator const RLI& () const;
  473.  
  474. // assignment operators ----------------------------------------------------
  475.  
  476.             TRLI&                    operator = ( const TRLI& );
  477.             TRLI&                    operator = ( const RLI& );
  478.             TRLI&                    operator = ( const PackedRLI& );
  479.  
  480. // comparison methods -------------------------------------------------------
  481.  
  482.             Boolean                    operator == ( const TRLI& ) const;
  483.             Boolean                    operator == ( const RLI& ) const;
  484.             Boolean                    operator == ( const PackedRLI& ) const;
  485.  
  486.             Boolean                    operator != ( const TRLI& ) const;
  487.             Boolean                    operator != ( const RLI& ) const;
  488.             Boolean                    operator != ( const PackedRLI& ) const;
  489.  
  490. // setters/getters ----------------------------------------------------------
  491.  
  492.             void                     SetDirectory ( const TDirectory& );
  493.             Boolean                 GetDirectory ( TDirectory& ) const; // returns true if record has a directory name
  494.             const DirectoryName*     GetDirectoryName () const;
  495.             const DirDiscriminator&    GetDirectoryDiscriminator () const;
  496.  
  497.             void                     SetNode ( DNodeNum );
  498.             DNodeNum                 GetNode () const; // returns true if record has a directory name
  499.  
  500.             void                    SetPathName ( const TPathName& );
  501.             Boolean                 GetPathName ( TPathName& ) const; // returns true if record has a path
  502.             const PackedPathName*     GetPathName () const;
  503.  
  504. // i/o methods --------------------------------------------------------------
  505.  
  506.             Boolean                    Read ( TAbstractFile& );
  507.             Boolean                    Write ( TAbstractFile& ) const;
  508.     virtual    ostream&                operator >> ( ostream& ) const;
  509.  
  510. // utility methods ----------------------------------------------------------
  511.  
  512.     static    unsigned short            GetPhysicalSize ( const PackedRLI* );
  513.     static    unsigned short            GetPhysicalSizeOfPacked ( const RLI* );
  514.  
  515. // debugging methods --------------------------------------------------------
  516.  
  517.             Boolean                    IsValid () const;
  518.     static    Boolean                    IsValid ( const RLI* );
  519.     static    Boolean                    IsValid ( const PackedRLI* );
  520.  
  521. protected:    PackedRLI*                fPacked;
  522.             RLI*                    fUnpacked;
  523.  
  524.             Boolean                    IsValidInternal () const;
  525.             void                    ValidateUnpacked () const;
  526.             Boolean                    ValidateUnpackedAndCheck () const;
  527.             void                    InvalidateUnpacked () const;
  528.             void                    Deallocate ();    // invalidates unpacked
  529.  
  530.     static    PackedRLI*                Allocate ( unsigned short bytes );
  531.     static    PackedRLI*                Allocate ( const RLI* );
  532.     static    PackedRLI*                Allocate ( const PackedRLI* );
  533.     static    void                    Deallocate ( PackedRLI*& );
  534.     static    Boolean                    IsValidInternal ( const RLI* p );
  535.     static    Boolean                    IsValidInternal ( const PackedRLI* p );
  536. };
  537.  
  538. /***********************************|****************************************/
  539.  
  540. class TRecordID : public TDirectObject
  541. {
  542. public:        TRecordID ();
  543.             TRecordID ( const RecordID* p );
  544.             TRecordID ( const RecordID& p );
  545.             TRecordID ( const PackedRecordID* p );
  546.             TRecordID ( const PackedRecordID& p );
  547.             TRecordID ( const TRecordID& r );
  548.  
  549.             TRecordID ( const TRString& name, const TRString& type, const DNodeNum d, const TDirectory& dir);
  550.             TRecordID ( const TRString& name, const TRString& type, const TPathName& p, const TDirectory& dir );
  551.             TRecordID ( const TRString& name, const TRString& type, const TRLI& rli);
  552.  
  553.             TRecordID ( const TCreationID& cid, const TPathName& p, const TDirectory& dir );
  554.             TRecordID ( const TCreationID& cid, const DNodeNum d, const TDirectory& dir );
  555.             TRecordID ( const TCreationID& cid, const TRLI& rli );
  556.  
  557.             TRecordID ( const LocalRecordID& localRecordID, const TPathName& p, const TDirectory& dir );
  558.             TRecordID ( const LocalRecordID& localRecordID, const DNodeNum d, const TDirectory& dir );
  559.             TRecordID ( const LocalRecordID& localRecordID, const TRLI& rli );
  560.  
  561.             ~TRecordID();
  562.  
  563. // conversion operators -----------------------------------------------------
  564.  
  565.     // these 4 routines provide read-only access, if you cast result to non-const, you’ll shoot yourself
  566.                                     operator const PackedRecordID* () const;
  567.                                     operator const PackedRecordID& () const;
  568.                                     operator const RecordID* () const;
  569.                                     operator const RecordID& () const;
  570.  
  571. // assignment operators ----------------------------------------------------
  572.  
  573.             TRecordID&                operator = ( const TRecordID& );
  574.             TRecordID&                operator = ( const RecordID& );
  575.             TRecordID&                operator = ( const RecordID* );
  576.             TRecordID&                operator = ( const PackedRecordID* );
  577.             TRecordID&                operator = ( const PackedRecordID& );
  578.  
  579. // comparison methods -------------------------------------------------------
  580.  
  581.             Boolean                    operator == ( const TRecordID& ) const;
  582.             Boolean                    operator == ( const RecordID& ) const;
  583.             Boolean                    operator == ( const RecordID* ) const;
  584.             Boolean                    operator == ( const PackedRecordID& ) const;
  585.             Boolean                    operator == ( const PackedRecordID* ) const;
  586.  
  587.             Boolean                    operator != ( const TRecordID& ) const;
  588.             Boolean                    operator != ( const RecordID& ) const;
  589.             Boolean                    operator != ( const RecordID* ) const;
  590.             Boolean                    operator != ( const PackedRecordID& ) const;
  591.             Boolean                    operator != ( const PackedRecordID* ) const;
  592.  
  593. // setters/getters methods --------------------------------------------------
  594.  
  595.             Boolean                     SetNode ( const DNodeNum );
  596.             DNodeNum                 GetNode () const;
  597.  
  598.             Boolean                     SetRecordName ( const TRString& );
  599.             Boolean                 GetRecordName ( TRString& ) const;
  600.  
  601.             Boolean                    SetRecordType ( const TRString& );
  602.             Boolean                 GetRecordType ( TRString& ) const;
  603.  
  604.             Boolean                    SetCreationID ( const TCreationID& );
  605.             Boolean                 GetCreationID ( TCreationID& ) const;
  606.  
  607.             Boolean                    SetDirectory ( const TDirectory& );
  608.             Boolean                 GetDirectory ( TDirectory& ) const;
  609.  
  610.             Boolean                    SetPathName ( const TPathName& );
  611.             Boolean                 GetPathName ( TPathName& ) const;
  612.  
  613.             Boolean                    SetRLI ( const TRLI& );
  614.             Boolean                 GetRLI ( TRLI& ) const;
  615.  
  616.             PackedRecordID*            GetNewPackedRecordID () const;    // makes recordIDPtr, allocates new fields
  617.  
  618. // i/o methods --------------------------------------------------------------
  619.  
  620.             Boolean                    Read ( TAbstractFile& );
  621.             Boolean                    Write ( TAbstractFile& ) const;
  622.     virtual    ostream&                operator >> ( ostream& ) const;
  623.  
  624. // utility methods ----------------------------------------------------------
  625.  
  626.     static    unsigned short            GetPhysicalSize ( const PackedRecordID* );
  627.     static    unsigned short            GetPhysicalSizeOfPacked ( const RecordID* );
  628.  
  629. // debugging methods --------------------------------------------------------
  630.  
  631.             Boolean                    IsValid () const;
  632.     static    Boolean                    IsValid ( const PackedRecordID* );
  633.     static    Boolean                    IsValid ( const RecordID* );
  634.  
  635. protected:    PackedRecordID*            fPacked;
  636.             RecordID*                fUnpacked;
  637.  
  638.             Boolean                    IsValidInternal () const;
  639.             void                    ValidateUnpacked () const;
  640.             Boolean                    ValidateUnpackedAndCheck () const;
  641.             void                    InvalidateUnpacked () const;
  642.             void                    Deallocate ();    // invalidates unpacked too
  643.             Boolean                    Adopt ( PackedRecordID* );
  644.             Boolean                    Set ( const RecordID* );
  645.             Boolean                    Set ( const PackedRLI* );
  646.  
  647.     static    PackedRecordID*            Allocate ( unsigned short bytes );
  648.     static    PackedRecordID*            Allocate ( const RecordID* );
  649.     static    PackedRecordID*            Allocate ( const PackedRecordID* );
  650.     static    void                    Deallocate ( PackedRecordID*& );
  651.     static    Boolean                    IsValidInternal ( const PackedRecordID* );
  652.     static    Boolean                    IsValidInternal ( const RecordID* );
  653. };
  654.  
  655. /***********************************|****************************************/
  656.  
  657. class TDSSpec : public TDirectObject
  658. {
  659. public:        TDSSpec ();
  660.             TDSSpec ( const RecordID* p, OSType extensionType, const void* extensionData = nil, unsigned long extensionLength = 0 );
  661.             TDSSpec ( const RecordID& p, OSType extensionType, const void* extensionData = nil, unsigned long extensionLength = 0);
  662.             TDSSpec ( const PackedRecordID* p, OSType extensionType, const void* extensionData = nil, unsigned long extensionLength = 0 );
  663.             TDSSpec ( const PackedRecordID& p, OSType extensionType, const void* extensionData = nil, unsigned long extensionLength = 0);
  664.             TDSSpec ( const TRecordID& r, OSType extensionType, const void* extensionData = nil, unsigned long extensionLength = 0 );
  665.             
  666.             TDSSpec ( const DSSpec* p );
  667.             TDSSpec ( const DSSpec& p );
  668.             TDSSpec ( const PackedDSSpec* p );
  669.             TDSSpec ( const PackedDSSpec& p );
  670.             TDSSpec ( const TDSSpec& r );
  671.  
  672.             TDSSpec ( const TRString& name, const TRString& type, const DNodeNum d, const TDirectory& dir, OSType extensionType, const void* extensionData = nil, unsigned long extensionLength = 0 );
  673.             TDSSpec ( const TRString& name, const TRString& type, const TPathName& p, const TDirectory& dir, OSType extensionType, const void* extensionData = nil, unsigned long extensionLength = 0);
  674.             TDSSpec ( const TRString& name, const TRString& type, const TRLI& rli, OSType extensionType, const void* extensionData = nil, unsigned long extensionLength = 0);
  675.  
  676.             TDSSpec ( const TCreationID& cid, const TPathName& p, const TDirectory& dir, OSType extensionType, const void* extensionData = nil, unsigned long extensionLength = 0 );
  677.             TDSSpec ( const TCreationID& cid, const DNodeNum d, const TDirectory& dir, OSType extensionType, const void* extensionData = nil, unsigned long extensionLength = 0 );
  678.             TDSSpec ( const TCreationID& cid, const TRLI& rli, OSType extensionType, const void* extensionData = nil, unsigned long extensionLength = 0);
  679.  
  680.             TDSSpec ( const LocalRecordID& localRecordID, const TPathName& p, const TDirectory& dir, OSType extensionType, const void* extensionData = nil, unsigned long extensionLength = 0);
  681.             TDSSpec ( const LocalRecordID& localRecordID, const DNodeNum d, const TDirectory& dir, OSType extensionType, const void* extensionData = nil, unsigned long extensionLength = 0 );
  682.             TDSSpec ( const LocalRecordID& localRecordID, const TRLI& rli, OSType extensionType, const void* extensionData = nil, unsigned long extensionLength = 0 );
  683.  
  684.             ~TDSSpec();
  685.  
  686. // conversion operators -----------------------------------------------------
  687.  
  688.     // these routines provide read-only access, if you cast result to non-const, you’ll shoot yourself
  689.                                     operator const PackedRecordID* () const;
  690.                                     operator const PackedRecordID& () const;
  691.                                     operator const RecordID* () const;
  692.                                     operator const RecordID& () const;
  693.                                     operator const PackedDSSpec* () const;
  694.                                     operator const PackedDSSpec& () const;
  695.                                     operator const DSSpec* () const;
  696.                                     operator const DSSpec& () const;
  697.                                     
  698. // assignment operators ----------------------------------------------------
  699.  
  700.             TDSSpec&                operator = ( const TDSSpec& );
  701.             TDSSpec&                operator = ( const DSSpec& );
  702.             TDSSpec&                operator = ( const DSSpec* );
  703.             TDSSpec&                operator = ( const PackedDSSpec* );
  704.             TDSSpec&                operator = ( const PackedDSSpec& );
  705.             
  706. // comparison methods -------------------------------------------------------
  707.  
  708.             Boolean                    operator == ( const TDSSpec& ) const;
  709.             Boolean                    operator == ( const DSSpec& ) const;
  710.             Boolean                    operator == ( const DSSpec* ) const;
  711.             Boolean                    operator == ( const PackedDSSpec& ) const;
  712.             Boolean                    operator == ( const PackedDSSpec* ) const;
  713.  
  714.             Boolean                    operator != ( const TDSSpec& ) const;
  715.             Boolean                    operator != ( const DSSpec& ) const;
  716.             Boolean                    operator != ( const DSSpec* ) const;
  717.             Boolean                    operator != ( const PackedDSSpec& ) const;
  718.             Boolean                    operator != ( const PackedDSSpec* ) const;
  719.  
  720. // setters/getters methods --------------------------------------------------
  721.  
  722.             Boolean                     SetNode ( const DNodeNum );
  723.             DNodeNum                 GetNode () const;
  724.  
  725.             Boolean                     SetRecordName ( const TRString& );
  726.             Boolean                 GetRecordName ( TRString& ) const;
  727.  
  728.             Boolean                    SetRecordType ( const TRString& );
  729.             Boolean                 GetRecordType ( TRString& ) const;
  730.  
  731.             Boolean                    SetCreationID ( const TCreationID& );
  732.             Boolean                 GetCreationID ( TCreationID& ) const;
  733.  
  734.             Boolean                    SetDirectory ( const TDirectory& );
  735.             Boolean                 GetDirectory ( TDirectory& ) const;
  736.  
  737.             Boolean                    SetPathName ( const TPathName& );
  738.             Boolean                 GetPathName ( TPathName& ) const;
  739.  
  740.             Boolean                    SetRLI ( const TRLI& );
  741.             Boolean                 GetRLI ( TRLI& ) const;
  742.  
  743.             PackedDSSpec*            GetNewPackedDSSpec () const;    // makes DSSpecPtr, allocates new fields
  744.             
  745.             OSType                    GetExtensionType () const;
  746.             unsigned long            GetExtensionSize() const;
  747.             const void *            GetExtensionValue () const;
  748.  
  749. // i/o methods --------------------------------------------------------------
  750.  
  751.             Boolean                    Read ( TAbstractFile& );
  752.             Boolean                    Write ( TAbstractFile& ) const;
  753.     virtual    ostream&                operator >> ( ostream& ) const;
  754.  
  755. // utility methods ----------------------------------------------------------
  756.  
  757.     static    unsigned short            GetPhysicalSize ( const PackedDSSpec* );
  758.     static    unsigned short            GetPhysicalSizeOfPacked ( const DSSpec* );
  759.  
  760. // debugging methods --------------------------------------------------------
  761.  
  762.             Boolean                    IsValid () const;
  763.     static    Boolean                    IsValid ( const PackedDSSpec* );
  764.     static    Boolean                    IsValid ( const DSSpec* );
  765.  
  766. protected:    PackedDSSpec*            fPacked;
  767.             DSSpec*                    fUnpacked;
  768.  
  769.             Boolean                    IsValidInternal () const;
  770.             void                    ValidateUnpacked () const;
  771.             Boolean                    ValidateUnpackedAndCheck () const;
  772.             void                    InvalidateUnpacked () const;
  773.             void                    Deallocate ();    // invalidates unpacked too
  774.             Boolean                    Adopt ( PackedDSSpec* );
  775.             Boolean                    Set ( const DSSpec* );
  776.             Boolean                    Set ( const PackedRLI* );
  777.  
  778.     static    PackedDSSpec*            Allocate ( unsigned short bytes );
  779.     static    PackedDSSpec*            Allocate ( const DSSpec* );
  780.     static    PackedDSSpec*            Allocate ( const PackedDSSpec* );
  781.     static    void                    Deallocate ( PackedDSSpec*& );
  782.     static    Boolean                    IsValidInternal ( const PackedDSSpec* );
  783.     static    Boolean                    IsValidInternal ( const DSSpec* );
  784. };
  785.  
  786. /***********************************|****************************************/
  787.  
  788. // handy streaming functions
  789.  
  790. extern ostream& operator << ( ostream& s, const RString& );
  791. extern ostream& operator << ( ostream& s, const DirectoryName& );
  792. extern ostream& operator << ( ostream& s, const CreationID& );
  793. extern ostream& operator << ( ostream& s, const DirDiscriminator& );
  794. extern ostream& operator << ( ostream& s, const PackedPathName& );
  795. extern ostream& operator << ( ostream& s, const RLI& );
  796. extern ostream& operator << ( ostream& s, const PackedRLI& );
  797. extern ostream& operator << ( ostream& s, const RecordID& );
  798. extern ostream& operator << ( ostream& s, const PackedRecordID& );
  799.  
  800. inline ostream& operator << (ostream& s, const ProtoPackedPathName& p) { return s << (const PackedPathName&) p; }
  801. inline ostream& operator << (ostream& s, const ProtoRString& p) { return s << (const RString&) p; }
  802. inline ostream& operator << (ostream& s, const NetworkSpec& p) { return s << (const RString&) p; }
  803.  
  804. #ifndef THINK_CPLUS
  805. //    Apparently, Think C++ doesn't like these functions.
  806. extern ostream& operator << ( ostream& s, const RString* );
  807. extern ostream& operator << ( ostream& s, const DirectoryName* );
  808. extern ostream& operator << ( ostream& s, const CreationID* );
  809. extern ostream& operator << ( ostream& s, const DirDiscriminator* );
  810. extern ostream& operator << ( ostream& s, const PackedPathName* );
  811. extern ostream& operator << ( ostream& s, const RLI* );
  812. extern ostream& operator << ( ostream& s, const PackedRLI* );
  813. extern ostream& operator << ( ostream& s, const RecordID* );
  814. extern ostream& operator << ( ostream& s, const PackedRecordID* );
  815.  
  816. inline ostream& operator << (ostream& s, const ProtoPackedPathName* p) { return s << (const PackedPathName*) p; }
  817. inline ostream& operator << (ostream& s, const ProtoRString* p) { return s << * (const RString*) p; }
  818. inline ostream& operator << (ostream& s, const NetworkSpec* p) { return s << * (const RString*) p; }
  819. #endif
  820.  
  821. /***********************************|****************************************/
  822.  
  823. // TRString inlines
  824.  
  825. inline unsigned short TRString::GetPhysicalSize ( unsigned short logicalSize ) { return logicalSize + sizeof ( ProtoRString ) + 1; } // extra byte for null terminator
  826. inline unsigned short TRString::GetLength () const { return fString->dataLength; }
  827. inline CharacterSet TRString::GetScript () const { return fString->charSet; }
  828. inline RStringKind TRString::GetKind () const { return fKind; }
  829. inline Boolean TRString::operator == ( const char* string ) const { return Compare ( string ) == 0; }
  830. inline Boolean TRString::operator != ( const char* string ) const { return Compare ( string ) != 0; }
  831. inline Boolean TRString::operator > ( const char* string ) const { return Compare ( string ) > 0; }
  832. inline Boolean TRString::operator < ( const char* string ) const { return Compare ( string ) < 0; }
  833. inline Boolean TRString::operator == ( const StringPtr string ) const { return Compare ( string ) == 0; }
  834. inline Boolean TRString::operator != ( const StringPtr string ) const { return Compare ( string ) != 0; }
  835. inline Boolean TRString::operator > ( const StringPtr string ) const { return Compare ( string ) > 0; }
  836. inline Boolean TRString::operator < ( const StringPtr string ) const { return Compare ( string ) < 0; }
  837. inline Boolean TRString::operator == ( const RString& string ) const { return Compare ( string ) == 0; }
  838. inline Boolean TRString::operator != ( const RString& string ) const { return Compare ( string ) != 0; }
  839. inline Boolean TRString::operator > ( const RString& string ) const { return Compare ( string ) > 0; }
  840. inline Boolean TRString::operator < ( const RString& string ) const { return Compare ( string ) < 0; }
  841. inline Boolean TRString::operator == ( const TRString& string ) const { return Compare ( string ) == 0; }
  842. inline Boolean TRString::operator != ( const TRString& string ) const { return Compare ( string ) != 0; }
  843. inline Boolean TRString::operator > ( const TRString& string ) const { return Compare ( string ) > 0; }
  844. inline Boolean TRString::operator < ( const TRString& string ) const { return Compare ( string ) < 0; }
  845. #if defined ( INTERNAL_CHECKS )
  846.     inline Boolean TRString::IsValidInternal () const { return IsValidInternal ( fString, fKind ); }
  847. #else
  848.     inline Boolean TRString::IsValidInternal () const { return true; }
  849.     inline Boolean TRString::IsValidInternal ( const RString*, RStringKind ) { return true; }
  850. #endif
  851.  
  852. /***********************************|****************************************/
  853.  
  854. // TDirectoryName inlines
  855.  
  856. inline TDirectoryName::operator const DirectoryName* () const { return (const DirectoryName*) TRString::operator const RString* (); }
  857. inline TDirectoryName::operator const DirectoryName& () const { return (const DirectoryName&) TRString::operator const RString& (); }
  858. inline const TDirectoryName& TDirectory::GetName () const { return fName; }
  859. inline const TDirDiscriminator& TDirectory::GetDiscriminator () const { return fDiscriminator; }
  860.  
  861. /***********************************|****************************************/
  862.  
  863. // TCreationID inlines
  864.  
  865. inline Boolean TCreationID::operator == ( const TCreationID& that ) const { return operator == ( that.fID ); }
  866. inline Boolean TCreationID::operator != ( const CreationID& that ) const { return !operator == ( that ); }
  867. inline Boolean TCreationID::operator != ( const TCreationID& that ) const { return !operator == ( that.fID ); }
  868. inline TCreationID::operator const CreationID* () const { return &fID; }
  869. inline TCreationID::operator const CreationID& () const { return fID; }
  870.  
  871. /***********************************|****************************************/
  872.  
  873. // TDirDiscriminator inlines
  874.  
  875. inline Boolean TDirDiscriminator::operator == ( const TDirDiscriminator& that ) const { return operator == ( that.fDiscriminator ); }
  876. inline Boolean TDirDiscriminator::operator != ( const TDirDiscriminator& that ) const { return !operator == ( that.fDiscriminator ); }
  877. inline Boolean TDirDiscriminator::operator != ( const DirDiscriminator& that ) const { return !operator == ( that ); }
  878. inline TDirDiscriminator::operator DirDiscriminator* () const { return &( (TDirDiscriminator*) this )->fDiscriminator; }
  879. inline TDirDiscriminator::operator DirDiscriminator& () const { return ( (TDirDiscriminator*) this )->fDiscriminator; }
  880.  
  881. /***********************************|****************************************/
  882.  
  883. // TDirectory inlines
  884.  
  885. inline Boolean TDirectory::operator != ( const TDirectory& that ) const { return !operator == ( that ); }
  886.  
  887. /***********************************|****************************************/
  888.  
  889. // TPathName inlines
  890.  
  891. inline TPathName::operator const PackedPathName* () const { return fPacked; }
  892. inline TPathName::operator const PackedPathName& () const { return *fPacked; }
  893. inline TPathName& TPathName::operator = ( const PackedPathName& p ) { return operator = ( &p ); }
  894. inline Boolean TPathName::operator != ( const TPathName& that ) const { return !operator == ( that ); }
  895. inline Boolean TPathName::operator != ( const PackedPathName& that ) const { return !operator == ( that ); }
  896. inline Boolean TPathName::IsNull () const { return ::OCEIsNullPackedPathName ( fPacked ); }
  897. inline PackedPathName* TPathName::GetNewPackedPath () const { return Allocate ( fPacked ); }
  898. inline Boolean TPathName::IsValid () const { return IsValid ( fPacked ); }
  899. #if defined ( INTERNAL_CHECKS )
  900.     inline Boolean TPathName::IsValidInternal () const { return IsValidInternal ( fPacked ); }
  901. #else
  902.     inline Boolean TPathName::IsValidInternal () const { return true; }
  903.     inline Boolean TPathName::IsValidInternal ( const PackedPathName* ) { return true; }
  904. #endif
  905.  
  906. /***********************************|****************************************/
  907.  
  908. // TRLI inlines
  909.  
  910. inline TRLI::operator const PackedRLI* () const { return fPacked; }
  911. inline TRLI::operator const PackedRLI& () const { return *fPacked; }
  912. inline Boolean TRLI::operator != ( const RLI& that ) const { return !operator == ( that ); }
  913. inline Boolean TRLI::IsValid () const { return IsValid ( fPacked ); }
  914. #if defined ( INTERNAL_CHECKS )
  915.     inline Boolean TRLI::IsValidInternal () const { return IsValidInternal ( fPacked ); }
  916. #else
  917.     inline Boolean TRLI::IsValidInternal () const { return true; }
  918.     inline Boolean TRLI::IsValidInternal ( const RLI* ) { return true; }
  919.     inline Boolean TRLI::IsValidInternal ( const PackedRLI* ) { return true; }
  920. #endif
  921.  
  922. /***********************************|****************************************/
  923.  
  924. // TRecordID inlines
  925.  
  926. inline TRecordID::operator const PackedRecordID* () const { return fPacked; }
  927. inline TRecordID::operator const PackedRecordID& () const { return *fPacked; }
  928. inline TRecordID& TRecordID::operator = ( const TRecordID& that ) { return operator = ( that.fPacked ); }
  929. inline TRecordID& TRecordID::operator = ( const RecordID& r ) { return operator = ( &r ); }
  930. inline TRecordID& TRecordID::operator = ( const PackedRecordID& r ) { return operator = ( &r ); }
  931. inline Boolean TRecordID::operator == ( const PackedRecordID& r ) const { return operator == ( &r ); }
  932. inline Boolean TRecordID::operator != ( const PackedRecordID* r ) const { return !operator == ( r ); }
  933. inline Boolean TRecordID::operator != ( const PackedRecordID& r ) const { return operator != ( &r ); }
  934. inline Boolean TRecordID::operator == ( const TRecordID& that ) const { return operator == ( that.fPacked ); }
  935. inline Boolean TRecordID::operator != ( const TRecordID& that ) const { return operator != ( that.fPacked ); }
  936. inline Boolean TRecordID::operator == ( const RecordID& r ) const { return operator == ( &r ); }
  937. inline Boolean TRecordID::operator != ( const RecordID* r ) const { return !operator == ( r ); }
  938. inline Boolean TRecordID::operator != ( const RecordID& r ) const { return operator != ( &r ); }
  939. inline PackedRecordID* TRecordID::GetNewPackedRecordID () const { return Allocate ( fPacked ); }
  940. inline Boolean TRecordID::IsValid () const { return IsValid ( fPacked ); }
  941. #if defined ( INTERNAL_CHECKS )
  942.     inline Boolean TRecordID::IsValidInternal () const { return IsValidInternal ( fPacked ); }
  943. #else
  944.     inline Boolean TRecordID::IsValidInternal () const { return true; }
  945.     inline Boolean TRecordID::IsValidInternal ( const RecordID* ) { return true; }
  946.     inline Boolean TRecordID::IsValidInternal ( const PackedRecordID* ) { return true; }
  947. #endif
  948.  
  949. /***********************************|****************************************/
  950.  
  951. // TDSSpec inlines
  952.  
  953. inline TDSSpec::operator const PackedDSSpec* () const { return fPacked; }
  954. inline TDSSpec::operator const PackedDSSpec& () const { return *fPacked; }
  955. inline TDSSpec& TDSSpec::operator = ( const TDSSpec& that ) { return operator = ( that.fPacked ); }
  956. inline TDSSpec& TDSSpec::operator = ( const DSSpec& r ) { return operator = ( &r ); }
  957. inline TDSSpec& TDSSpec::operator = ( const PackedDSSpec& r ) { return operator = ( &r ); }
  958. inline Boolean TDSSpec::operator == ( const PackedDSSpec& r ) const { return operator == ( &r ); }
  959. inline Boolean TDSSpec::operator != ( const PackedDSSpec* r ) const { return !operator == ( r ); }
  960. inline Boolean TDSSpec::operator != ( const PackedDSSpec& r ) const { return operator != ( &r ); }
  961. inline Boolean TDSSpec::operator == ( const TDSSpec& that ) const { return operator == ( that.fPacked ); }
  962. inline Boolean TDSSpec::operator != ( const TDSSpec& that ) const { return operator != ( that.fPacked ); }
  963. inline Boolean TDSSpec::operator == ( const DSSpec& r ) const { return operator == ( &r ); }
  964. inline Boolean TDSSpec::operator != ( const DSSpec* r ) const { return !operator == ( r ); }
  965. inline Boolean TDSSpec::operator != ( const DSSpec& r ) const { return operator != ( &r ); }
  966. inline PackedDSSpec* TDSSpec::GetNewPackedDSSpec () const { return Allocate ( fPacked ); }
  967. inline Boolean TDSSpec::IsValid () const { return IsValid ( fPacked ); }
  968. #if defined ( INTERNAL_CHECKS )
  969.     inline Boolean TDSSpec::IsValidInternal () const { return IsValidInternal ( fPacked ); }
  970. #else
  971.     inline Boolean TDSSpec::IsValidInternal () const { return true; }
  972.     inline Boolean TDSSpec::IsValidInternal ( const DSSpec* ) { return true; }
  973.     inline Boolean TDSSpec::IsValidInternal ( const PackedDSSpec* ) { return true; }
  974. #endif
  975.  
  976. /***********************************|****************************************/
  977.  
  978. #pragma pop
  979.  
  980. #endif    // __OCEOBJECTS__
  981.